// AI接口配置
const API_URL = "https://api.qingyuntop.top/v1/chat/completions";
const API_KEY = "sk-KTRNwdYgAuIKJSguAn57JlUl2nzPE30PVdkws1v2zA9nyHmg";
// const API_KEY = "sk-XkOBvgGlVP4XM3jWi78odK29nP7dkAj69Q0IOB7FaXbUHEa8";
const MODEL = "meta-llama/llama-4-maverick";
const MAX_TOKENS = 8192;
const TEMPERATURE = 0.3;

/**
 * 调用硅基流动AI接口（纯文本版）
 * @param {string} prompt - 用户提示词
 * @param {object} bankData - 题库数据
 * @param {string} systemPrompt - 系统提示词
 * @description: 对题库进行分析，并返回结果
 */
const callSiliconAI = async (prompt, bankData, systemPrompt) => {
  const messages = [];
  if (systemPrompt) {
    messages.push({
      role: "system",
      content: systemPrompt,
    });
  }
  messages.push({
    role: "user",
    content: `请用纯文本分析题库：${JSON.stringify(
      bankData
    )}\n\n要求：${prompt}`,
  });

  const response = await fetch(API_URL, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: MODEL,
      messages,
      max_tokens: MAX_TOKENS,
      temperature: TEMPERATURE,
    }),
  });
  console.log(response);

  if (!response.ok) throw new Error("API请求失败");
  const data = await response.json();
  return data.choices[0].message.content.trim();
};

/**
 * 一键智能生成题库
 * @param {object} options - 快速生成选项
 * @param {string} options.keywords - 主题关键词
 * @param {number} options.questionCount - 题目数量
 * @param {string} options.difficultyBias - 难度倾向
 * @param {array} options.preferredTypes - 偏好题型
 * @param {string} options.fileContent - 参考文件内容（可选）
 * @description: 根据用户偏好快速生成完整题库
 * @returns {object} - 返回生成的完整题库对象
 */
const quickGenerateBank = async (options) => {
  // 构建系统提示词
  const systemPrompt = `
        你是一位专业的教育内容创建者，可以根据用户需求智能生成高质量题库。
        请根据用户提供的主题和偏好，创建一个完整的JSON格式题库，包含指定数量和类型的题目。【重要】总题目数量必须严格等于${
          options.questionCount
        }题，不能多也不能少。
        ${
          options.fileContent
            ? "你需要基于用户提供的参考文件内容来生成题目，确保题目内容与参考文件高度相关。"
            : ""
        }
        ${
          options.fileContent
            ? "请根据参考文件内容自动生成合适的题库名称和简洁描述，确保描述不包含题目数量。"
            : ""
        }
        返回格式必须根据模版生成，并且是严格可解析的JSON对象，不要任何注释，包含以下结构：
        {
            "bankName": "${
              options.fileContent
                ? '根据参考文件内容生成合适的题库名称，不要包含"题库"两个字'
                : "题库名称"
            }",
            "bankDescription": "${
              options.fileContent
                ? "根据参考文件内容生成简洁的题库描述，不要包含题目数量信息"
                : "题库描述"
            }",
            "questions": [
                {
                    "content": "题目内容",
                    "type": 0, // 0=单选题，1=多选题，2=填空题，3=判断题，4=简答题
                    "difficulty": 5, // 难度1-10，1-3=简单，4-7=中等，8-10=困难
                    "options": "选项1,选项2,选项3,选项4", //
                    "parse": "答案解析",
                    "answer": "选项1" // 单选题=选项，多选题=多个选项逗号隔开，判断题=选项，填空和简答=文本
                }
            ]
        }
        其中五种题型的模版如下：
        // 单选题
        {
            "content": "下列哪一项是人工智能的英文翻译？",
            "type": 0,
            "difficulty": 5,
            "options": "Artificial Intelligence,Human Intelligence,Machine Learning,Robot Thinking",
            "parse": "人工智能的英文是 Artificial Intelligence。",
            "answer": "Artificial Intelligence"
        },
        // 多选题
        {
            "content": "以下哪些属于机器学习的常用算法？",
            "type": 1,
            "difficulty": 6,
            "options": "决策树,支持向量机,线性回归,冒泡排序",
            "parse": "前三项是机器学习算法，冒泡排序是排序算法。",
            "answer": "决策树,支持向量机,线性回归"
        },
        // 判断题 - 必须是明确的陈述句
        {
            "content": "深度学习是机器学习的一个分支。",
            "type": 3,
            "difficulty": 4,
            "options": "正确,错误",
            "parse": "深度学习确实是机器学习的一个分支。",
            "answer": "正确"
        },
        // 填空题 - 必须包含下划线
        {
            "content": "人工智能的英文缩写是____。",
            "type": 2,
            "difficulty": 3,
            "options": "",
            "parse": "人工智能的英文缩写是 AI。",
            "answer": "AI"
        },
        // 简答题
        {
            "content": "请简述人工智能的主要应用领域。",
            "type": 4,
            "difficulty": 7,
            "options": "",
            "parse": "人工智能应用于医疗、金融、自动驾驶、智能家居等领域。",
            "answer": ""
        }
        
        特别注意：
        1. 【重要】填空题(type=2)必须在题目内容中明确包含下划线"____"表示空白处，答案是填入空白处的内容。
           * 正确示例: "Python中用于创建空字典的语法是____。" (答案: "{}" 或 "dict()")
           * 错误示例: "Python中用于创建空字典的语法是什么？" (这是问句，不是填空题)
        
        2. 【非常重要】判断题(type=3)的严格要求：
           * 判断题内容必须是陈述句，判断对错，例如："Python是一种编程语言。"
           * 绝对不能是问句形式，例如："Python是一种编程语言吗？" 这样的问句不可接受
           * 选项必须固定为"正确,错误"
           * 答案必须是"正确"或"错误"
           * 判断题绝对不能包含下划线"____"或任何填空符号
           * 判断题不能包含"是什么"、"如何"、"为什么"、"哪些"等疑问词
           * 正确示例: "Python中的字典是通过键来访问元素的。" (答案: "正确")
           * 错误示例: "Python中的字典是通过____来访问元素的。" (这包含填空符号)
           * 错误示例: "Python中的字典是通过什么来访问元素的？" (这是问句)
           * 错误示例: "Python中的字典使用什么方式访问元素？" (这是问句)
        
        3. 确保题目内容高质量、符合教育标准，答案和解析准确合理
        
        4. 注意区分题型：
           * 单选题(type=0): 问句，提供多个选项，只有一个正确答案
           * 多选题(type=1): 问句，提供多个选项，有多个正确答案
           * 填空题(type=2): 一定包含"____"符号表示空白处，答案填入空白处
           * 判断题(type=3): 一定是陈述句，判断对错，无空白符号"____"
           * 简答题(type=4): 问句，需要较长文字回答
         注意：一定要区分判断题和简答题，不要混淆！！！！。
         6. 请严格按照题目类型和数量生成题目，不要漏掉任何一种题型，不要生成重复的题目，不要生成不符合题型要求的题目！！！！！
         7. 单选题和多选题必须至少4个选项并且单选题只有一个答案，多选题有多个答案多个答案用逗号隔开，判断题两个选项，填空题没有选项只有答案和解析它的多个答案用逗号隔开但是题目需要给足填空的下划线，还有就是简单题它是没有选项和答案的只有答案解析
         8. 【非常重要】必须确保生成的题目总数严格等于${
           options.questionCount
         }题，请在提交前检查题目数量。如果不等于${
    options.questionCount
  }题，请调整使其数量精确无误。
        `;

  // 构建用户提示词
  const typeMap = {
    single: "单选题(type=0)",
    multiple: "多选题(type=1)",
    fillblank: "填空题(type=2)",
    truefalse: "判断题(type=3)",
    shortanswer: "简答题(type=4)",
  };

  const difficultyMap = {
    easy: "简单(difficulty=1-3)",
    medium: "中等(difficulty=4-7)",
    hard: "困难(difficulty=8-10)",
  };

  let userPrompt = `请为我生成一个${
    options.keywords ? `关于"${options.keywords}"的` : ""
  }题库，包含以下要素：
    1. 总共必须生成恰好${options.questionCount}道题目，不能多也不能少
    2. 难度倾向：${difficultyMap[options.difficultyBias] || "中等"}
    3. 题目类型偏好：${options.preferredTypes
      .map((type) => typeMap[type] || type)
      .join("、")}

    所有题型都必须包含，不可漏掉。请确保生成的题目总数恰好为${
      options.questionCount
    }道，这一点非常重要。`;

  // 如果有参考文件，添加文件内容
  if (options.fileContent) {
    userPrompt += `\n\n请根据以下参考文件内容生成题库，题目应该与文件内容高度相关：\n${options.fileContent.substring(
      0,
      3000
    )}`;
    if (options.fileContent.length > 3000) userPrompt += "\n...(内容已截断)";

    userPrompt += `\n\n请根据参考文件内容自动生成合适的题库名称和描述，确保：
        - 题库名称应简洁准确，不要包含"题库"两个字
        - 题库描述应概括题库主题，不要包含题目数量信息
        - 所有题目应与参考文件内容高度相关
        - 【重要】判断题必须是陈述句而不是问句，例如"Python是一种编程语言"而不是"Python是一种编程语言吗？"`;
  } else {
    userPrompt += `\n\n请为题库生成一个合适的名称和简短描述。
        【重要】生成的题库名称中不要包含"题库"这两个字！请取一个更加专业和创新的名称。
        【重要】判断题必须是陈述句而不是问句，例如"Python是一种编程语言"而不是"Python是一种编程语言吗？"`;
  }

  userPrompt += `\n所有内容请以JSON格式返回，确保结构严格正确，可被直接解析使用。请再次核对生成的题目数量是否确实等于${options.questionCount}道，不要漏题少题。切记，切记，切记！！！！！`;

  // 发送请求
  const response = await fetch(API_URL, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: MODEL,
      messages: [
        { role: "system", content: systemPrompt },
        { role: "user", content: userPrompt },
      ],
      max_tokens: MAX_TOKENS,
      temperature: TEMPERATURE,
    }),
  });

  if (!response.ok) throw new Error("一键生成API请求失败");
  const data = await response.json();
  const content = data.choices[0].message.content.trim();

  // 尝试解析JSON响应
  try {
    // 找到内容中的JSON部分
    const jsonMatch = content.match(/\{[\s\S]*\}/);
    if (jsonMatch) {
      const jsonString = jsonMatch[0];
      const parsedData = JSON.parse(jsonString);

      // 验证判断题格式
      if (parsedData.questions && Array.isArray(parsedData.questions)) {
        parsedData.questions = parsedData.questions.map((question) => {
          // 如果是判断题，但内容是问句或包含问号，自动转换为简答题
          if (question.type === 3) {
            // 检查是否为问句（以问号结尾或包含特定问句词语）
            const isQuestion =
              question.content.endsWith("?") ||
              question.content.endsWith("？") ||
              /(?:是什么|什么是|如何|怎样|为什么|哪些|列举|请说明|简述|概述|说明)/.test(
                question.content
              );

            // 如果是问句，将其转换为简答题
            if (isQuestion) {
              console.log(
                "检测到格式错误的判断题，自动转换为简答题:",
                question.content
              );
              question.type = 4; // 简答题
              question.options = ""; // 清除选项
            } else {
              // 确保判断题选项正确
              question.options = "正确,错误";
              // 规范化答案
              question.answer =
                question.answer === "正确" || question.answer === "A"
                  ? "正确"
                  : "错误";
            }
          }
          return question;
        });

        // 如果题目数量超出了要求，则删除多余的题目
        if (parsedData.questions.length > options.questionCount) {
          parsedData.questions = parsedData.questions.slice(
            0,
            options.questionCount
          );
        }
      }
      console.log("parsedData", parsedData);

      return parsedData;
    } else {
      throw new Error("无法在响应中找到有效的JSON");
    }
  } catch (error) {
    console.error("解析一键生成响应失败:", error);
    console.log("AI原始响应:", content);
    throw new Error("解析生成内容失败，请重试");
  }
};

/**
 * 生成题库模板
 * @description: 使用AI生成多个题库模板
 * @returns {array} - 返回生成的题库模板数组
 */
const generateTemplates = async () => {
  // 构建系统提示词
  const systemPrompt = `
        你是一位专业的教育内容创建者，可以根据用户需求智能生成高质量题库模板。
        请生成多个不同领域的题库模板，每个模板应包含以下字段：
        {
            "id": "模板唯一标识符",
            "name": "模板名称",
            "description": "模板描述",
            "keywords": "相关关键词，以逗号分隔",
            "structure": {
                "single": 单选题数量,
                "multiple": 多选题数量,
                "truefalse": 判断题数量,
                "fillblank": 填空题数量,
                "shortanswer": 简答题数量
            },
            "difficulty": "easy/medium/hard"
        }
        
        每个模板应该覆盖不同的领域，如编程、数学、科学、语言等。
        模板的总题目数量应控制在15-25之间，确保各类题型都有合理分配。
        每个模板名称后缀不要为"题库"
        确保返回的是严格可解析的JSON数组。`;

  // 构建用户提示词
  const userPrompt = `请生成6个多样化的题库模板，涵盖不同领域和学科。
    每个模板应该有独特的主题和合理的题型分布结构。
    请确保模板之间的差异性，以便用户有多样化的选择。
    【重要】模板名称中不要使用"题库"这个词！
    所有内容请以JSON数组格式返回，确保结构严格正确，可被直接解析使用。`;

  // 发送请求
  try {
    const response = await fetch(API_URL, {
      method: "POST",
      headers: {
        Authorization: `Bearer ${API_KEY}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        model: MODEL,
        messages: [
          { role: "system", content: systemPrompt },
          { role: "user", content: userPrompt },
        ],
        max_tokens: MAX_TOKENS,
        temperature: TEMPERATURE,
      }),
    });

    if (!response.ok) throw new Error("模板生成API请求失败");
    const data = await response.json();
    const content = data.choices[0].message.content.trim();

    // 尝试解析JSON响应
    try {
      // 找到内容中的JSON数组部分
      const jsonMatch = content.match(/\[[\s\S]*\]/);
      if (jsonMatch) {
        const jsonString = jsonMatch[0];
        return JSON.parse(jsonString);
      } else {
        throw new Error("无法在响应中找到有效的JSON数组");
      }
    } catch (error) {
      console.error("解析模板生成响应失败:", error);
      console.log("AI原始响应:", content);
      throw new Error("解析模板内容失败，请重试");
    }
  } catch (error) {
    console.error("模板生成请求失败:", error);
    throw error;
  }
};

/**
 * 根据配置和可能的参考文件生成题库
 * @param {object} config - 生成配置
 * @param {string} config.keywords - 主题关键词
 * @param {object} config.questionTypes - 题型配置及数量
 * @param {string} config.difficulty - 难度级别
 * @param {string} config.fileContent - 参考文件内容(可选)
 * @param {object} bankData - 题库基本信息
 * @description: 根据用户配置和可能的参考文件生成题库
 * @returns {object} - 返回生成的题库对象
 */
const generateWithReference = async (config, bankData) => {
  // 判断是否需要自动生成题库信息
  const shouldAutoGenerateBankInfo =
    config.fileContent && (!bankData.name || !bankData.description);

  // 构建系统提示词
  const systemPrompt = `
        你是一位专业的教育内容创建者，可以根据用户需求智能生成高质量题库。
        请根据用户提供的主题、题型配置和偏好，创建一个完整的JSON格式题库，包含指定数量和类型的题目，出题数量最大不能超过30题。
        【非常重要】必须严格按照用户指定的题型和数量生成题目，不能多也不能少，请在提交前仔细检查每种题型的数量是否与要求一致。
        ${
          config.fileContent
            ? "你需要基于用户提供的参考文件内容来生成题目，确保题目内容与参考文件高度相关。"
            : ""
        }
        ${
          shouldAutoGenerateBankInfo
            ? "请根据参考文件内容自动生成合适的题库名称和简洁描述，确保描述不包含题目数量。"
            : ""
        }
        
        返回格式必须根据模版生成，并且是严格可解析的JSON对象，不要任何注释，包含以下结构：
        {
            "bankName": "${
              bankData.name || '根据内容生成合适的题库名称，后缀不要为"题库"'
            }",
            "bankDescription": "${
              bankData.description ||
              "根据内容生成简洁的题库描述，不要包含题目数量信息"
            }",
            "questions": [
                {
                    "content": "题目内容",
                    "type": 0, // 0=单选题，1=多选题，2=填空题，3=判断题，4=简答题
                    "difficulty": 5, // 难度1-10，1-3=简单，4-7=中等，8-10=困难
                    "options": "选项1,选项2,选项3,选项4", //
                    "parse": "答案解析",
                    "answer": "选项1" // 单选题=选项，多选题=多个选项逗号隔开，判断题=选项，填空和简答=文本
                }
            ]
        }
        其中五种题型的模版如下：
        // 单选题
        {
            "content": "下列哪一项是人工智能的英文翻译？",
            "type": 0,
            "difficulty": 5,
            "options": "Artificial Intelligence,Human Intelligence,Machine Learning,Robot Thinking",
            "parse": "人工智能的英文是 Artificial Intelligence。",
            "answer": "Artificial Intelligence"
        },
        // 多选题
        {
            "content": "以下哪些属于机器学习的常用算法？",
            "type": 1,
            "difficulty": 6,
            "options": "决策树,支持向量机,线性回归,冒泡排序",
            "parse": "前三项是机器学习算法，冒泡排序是排序算法。",
            "answer": "决策树,支持向量机,线性回归"
        },
        // 判断题 - 必须是明确的陈述句
        {
            "content": "深度学习是机器学习的一个分支。",
            "type": 3,
            "difficulty": 4,
            "options": "正确,错误",
            "parse": "深度学习确实是机器学习的一个分支。",
            "answer": "正确"
        },
        // 填空题 - 必须包含下划线
        {
            "content": "人工智能的英文缩写是____。",
            "type": 2,
            "difficulty": 3,
            "options": "",
            "parse": "人工智能的英文缩写是 AI。",
            "answer": "AI"
        },
        // 简答题
        {
            "content": "请简述人工智能的主要应用领域。",
            "type": 4,
            "difficulty": 7,
            "options": "",
            "parse": "人工智能应用于医疗、金融、自动驾驶、智能家居等领域。",
            "answer": ""
        }
        
        特别注意：
        1. 【重要】填空题(type=2)必须在题目内容中明确包含下划线"____"表示空白处，答案是填入空白处的内容。
           * 正确示例: "Python中用于创建空字典的语法是____。" (答案: "{}" 或 "dict()")
           * 错误示例: "Python中用于创建空字典的语法是什么？" (这是问句，不是填空题)
        
        2. 【非常重要】判断题(type=3)的严格要求：
           * 判断题内容必须是陈述句，判断对错，例如："Python是一种编程语言。"
           * 绝对不能是问句形式，例如："Python是一种编程语言吗？" 这样的问句不可接受
           * 选项必须固定为"正确,错误"
           * 答案必须是"正确"或"错误"
           * 判断题绝对不能包含下划线"____"或任何填空符号
           * 判断题不能包含"是什么"、"如何"、"为什么"、"哪些"等疑问词
           * 正确示例: "Python中的字典是通过键来访问元素的。" (答案: "正确")
           * 错误示例: "Python中的字典是通过____来访问元素的。" (这包含填空符号)
           * 错误示例: "Python中的字典是通过什么来访问元素的？" (这是问句)
           * 错误示例: "Python中的字典使用什么方式访问元素？" (这是问句)
        
        3. 确保题目内容高质量、符合教育标准，答案和解析准确合理
        
        4. 注意区分题型：
           * 单选题(type=0): 问句，提供多个选项，只有一个正确答案
           * 多选题(type=1): 问句，提供多个选项，有多个正确答案
           * 填空题(type=2): 一定包含"____"符号表示空白处，答案填入空白处
           * 判断题(type=3): 一定是陈述句，判断对错，无空白符号"____"
           * 简答题(type=4): 问句，需要较长文字回答
           
        5. 【重要】题库名称和描述：
           * 如果需要自动生成题库名称，请根据参考文件内容生成一个简洁、有意义的名称
           * 题库描述应该简明扼要地说明题库的主题和内容，不超过50个字
           * 描述中绝对不要包含题目数量信息，如"包含XX题"、"共XX道题"等
        6. 请严格按照题目类型和数量生成题目，不要漏掉任何一种题型，不要生成重复的题目，不要生成不符合题型要求的题目！！！！！
        7. 单选题和多选题必须至少4个选项并且单选题只有一个答案，多选题有多个答案多个答案用逗号隔开，判断题两个选项，填空题没有选项只有答案和解析它的多个答案用逗号分隔但是题目需要给足填空的下划线，还有就是简单题它是没有选项和答案的只有答案解析
        8. 【非常重要】请在提交前仔细检查每种题型的数量，确保与要求完全一致，不要多也不要少。题型种类和数量必须严格遵照用户指定的配置生成。
            `;

  // 准备题型数量配置
  const questionTypeConfig = {};
  for (const [type, count] of Object.entries(config.questionTypes)) {
    if (count > 0) {
      // 将前端题型字符串映射到数字
      const typeMap = {
        single: 0,
        multiple: 1,
        fillblank: 2,
        truefalse: 3,
        shortanswer: 4,
      };
      questionTypeConfig[typeMap[type] || 0] = count;
    }
  }

  // 准备难度级别
  const difficultyMap = {
    easy: "简单(difficulty=1-3)",
    medium: "中等(difficulty=4-7)",
    hard: "困难(difficulty=8-10)",
  };

  // 构建用户提示词
  let userPrompt = `请为我生成一个${
    config.keywords ? `关于"${config.keywords}"的` : ""
  }题库，具体要求如下：
    
    1. 题库基本信息：
       ${
         shouldAutoGenerateBankInfo
           ? '* 请根据提供的参考文件内容自动生成合适的题库名称和描述，题库名称后缀不要为"题库"'
           : `* 名称：${bankData.name || "请生成一个合适的题库名称"}
       * 描述：${bankData.description || "请生成一个简短的题库描述"}`
       }
    
    2. 题型配置及数量：
       ${Object.entries(config.questionTypes)
         .filter(([_, count]) => count > 0)
         .map(([type, count]) => {
           const typeNames = {
             single: "单选题",
             multiple: "多选题",
             fillblank: "填空题",
             truefalse: "判断题",
             shortanswer: "简答题",
           };
           return `* ${typeNames[type] || type}：${count}道`;
         })
         .join("\n       ")}
    
    3. 题目难度：${difficultyMap[config.difficulty] || "中等"}

    【非常重要】请严格按照上述每种题型的具体数量生成题目，不能多也不能少，每种题型的数量必须精确匹配要求。
    `;

  // 如果有参考文件，添加文件内容
  if (config.fileContent) {
    userPrompt += `\n\n4. 参考文件内容（请基于此生成题目${
      shouldAutoGenerateBankInfo ? "和题库信息" : ""
    }）：\n${config.fileContent.substring(0, 3000)}`;
    if (config.fileContent.length > 3000) userPrompt += "\n...(内容已截断)";
  }

  userPrompt += `\n\n请确保题库中的每个题目都符合对应题型的格式要求，特别注意：
    - 填空题必须包含"____"下划线表示空白处
    - 【重要】判断题必须是陈述句而不是问句，例如"Python是一种编程语言"而不是"Python是一种编程语言吗？"
    ${
      shouldAutoGenerateBankInfo
        ? "题库描述应该简明扼要，绝对不要包含题目数量信息。"
        : ""
    }
    所有内容请以JSON格式返回，确保结构严格正确，可被直接解析使用。
    
    提交前请检查并确认：
    1. 每种题型的数量是否与要求完全一致
    2. 题目内容是否符合相应题型的格式要求
    3. 所有题目格式是否正确，选项和答案是否合理
    `;

  // 发送请求
  const response = await fetch(API_URL, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: MODEL,
      messages: [
        { role: "system", content: systemPrompt },
        { role: "user", content: userPrompt },
      ],
      max_tokens: MAX_TOKENS,
      temperature: TEMPERATURE,
    }),
  });

  if (!response.ok) throw new Error("生成题库API请求失败");
  const data = await response.json();
  const content = data.choices[0].message.content.trim();

  // 尝试解析JSON响应
  try {
    // 找到内容中的JSON部分
    const jsonMatch = content.match(/\{[\s\S]*\}/);
    if (jsonMatch) {
      const jsonString = jsonMatch[0];
      const result = JSON.parse(jsonString);

      // 确保描述中不包含题目数量信息
      if (result.bankDescription) {
        result.bankDescription = result.bankDescription
          .replace(/[，,。.\s]*共\s*\d+\s*[道]?题[目]?.*$/g, "")
          .replace(/[，,。.\s]*包[含括]\s*\d+\s*[道]?题[目]?.*$/g, "")
          .replace(/[，,。.\s]*总计\s*\d+\s*[道]?题[目]?.*$/g, "");
      }

      // 验证判断题格式
      if (result.questions && Array.isArray(result.questions)) {
        result.questions = result.questions.map((question) => {
          // 如果是判断题，但内容是问句或包含问号，自动转换为简答题
          if (question.type === 3) {
            // 检查是否为问句（以问号结尾或包含特定问句词语）
            const isQuestion =
              question.content.endsWith("?") ||
              question.content.endsWith("？") ||
              /(?:是什么|什么是|如何|怎样|为什么|哪些|列举|请说明|简述|概述|说明)/.test(
                question.content
              );

            // 如果是问句，将其转换为简答题
            if (isQuestion) {
              console.log(
                "检测到格式错误的判断题，自动转换为简答题:",
                question.content
              );
              question.type = 4; // 简答题
              question.options = ""; // 清除选项
            } else {
              // 确保判断题选项正确
              question.options = "正确,错误";
              // 规范化答案
              question.answer =
                question.answer === "正确" || question.answer === "A"
                  ? "正确"
                  : "错误";
            }
          }
          return question;
        });
      }
      console.log("生成结果：", result);

      return result;
    } else {
      throw new Error("无法在响应中找到有效的JSON");
    }
  } catch (error) {
    console.error("解析生成响应失败:", error);
    console.log("AI原始响应:", content);
    throw new Error("解析生成内容失败，请重试");
  }
};

/**
 * 重新生成单个题目
 * @param {object} config - 生成配置
 * @param {string} config.keywords - 主题关键词
 * @param {string} config.difficulty - 难度级别
 * @param {string} config.type - 题型
 * @param {string} config.fileContent - 参考文件内容(可选)
 * @description: 根据配置和可能的参考文件重新生成单个题目
 * @returns {object} - 返回生成的题目对象
 */
const regenerateQuestion = async (config) => {
  // 检查是否有参考文件
  const hasReferenceFile = !!config.fileContent;

  // 构建系统提示词
  const systemPrompt = `
        你是一位专业的教育内容创建者，专注于生成高质量的考试题目。
        请根据用户提供的要求，生成一道${
          config.keywords ? `关于"${config.keywords}"的` : ""
        }${getTypeName(config.type)}题目。
        ${
          hasReferenceFile
            ? "请基于提供的参考文件内容生成题目，确保题目内容与参考文件高度相关，且具有教育测试价值。"
            : ""
        }
        
        返回格式必须是严格可解析的JSON对象，仅包含单个题目对象，结构如下：
        {
            "content": "题目内容",
            "type": ${getTypeCode(
              config.type
            )}, // 0=单选题，1=多选题，2=填空题，3=判断题，4=简答题
            "difficulty": ${getDifficultyNumber(
              config.difficulty
            )}, // 难度1-10，1-3=简单，4-7=中等，8-10=困难
            "options": "选项1,选项2,选项3,选项4", // 选择题的选项，用逗号分隔
            "parse": "答案解析",
            "answer": "选项1" // 单选题=选项文本，多选题=多个选项文本(逗号分隔)，判断题=正确或错误，填空=答案文本，简答题=空
        }

        【非常重要】各题型格式严格要求:
        1. 【单选题】(type=0): 
           - 必须是问句形式
           - options格式必须为"选项1,选项2,选项3,选项4"，用逗号分隔，不要添加字母前缀
           - answer必须是完整的选项文本，与options中的某一项完全匹配
        
        2. 【多选题】(type=1): 
           - 必须是问句形式
           - options格式必须为"选项1,选项2,选项3,选项4"，用逗号分隔，不要添加字母前缀
           - answer必须是多个完整选项文本，用逗号分隔，每个选项与options中的项完全匹配
        
        3. 【填空题】(type=2):
           - 【重要】必须在题目内容中包含下划线"____"表示空白处
           - 有几个答案就要有几个下划线
           - 不能是问句形式，必须是陈述句中包含空白需要填写
           - answer为填入空白处的正确答案，多个答案用逗号分隔
           - options字段为空字符串
        
        4. 【判断题】(type=3):
           - 必须是明确的陈述句，不能是问句
           - options必须为"正确,错误"
           - answer必须是"正确"或"错误"
           - 【严禁】不能包含下划线"____"或任何填空符号
        
        5. 【简答题】(type=4):
           - 必须是开放式问题
           - answer必须为空字符串
           - options字段为空字符串
           - 必须提供详细的parse(参考解析)
        
        确保所有题目符合教育测试标准，内容准确，表述清晰，答案无歧义。
        确保新题目与提供的参考资料内容高度相关，切记不要重复原题的知识点。
        
        【特别强调】：
        1. 选项格式必须是纯文本，逗号分隔，不要添加任何字母编号或前缀
        2. 答案必须与选项完全匹配，包括标点符号和空格
        3. 多选题答案必须是完整选项文本，不是字母，多个答案用逗号分隔
        4. 填空题答案用逗号分隔，有几个下划线就要有几个答案
        5. 简答题没有选项和答案，只有答案解析
        `;

  // 构建用户提示词
  let userPrompt = `请为我生成一道高质量的${
    config.keywords ? `关于"${config.keywords}"的` : ""
  }${getTypeName(config.type)}题，难度为${config.difficulty}。`;

  // 如果有参考文件，添加文件内容
  if (hasReferenceFile) {
    userPrompt += `\n\n请基于以下参考内容生成题目：\n${config.fileContent.substring(
      0,
      2000
    )}`;
    if (config.fileContent.length > 2000) userPrompt += "\n...(内容已截断)";
  }

  userPrompt += `\n\n请遵守以下格式要求：
    - 选项必须是纯文本，用逗号分隔，不要添加字母编号或前缀
    - 单选题答案必须是完整的选项文本
    - 多选题答案必须是多个完整选项文本，用逗号分隔
    - 填空题必须包含下划线"____"作为空白处，有几个答案就有几个下划线
    - 判断题必须是陈述句，答案必须是"正确"或"错误"
    - 简答题没有选项和答案，只有答案解析
    
    请直接返回JSON对象，不要包含任何额外说明。`;

  // 发送请求
  const response = await fetch(API_URL, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: MODEL,
      messages: [
        { role: "system", content: systemPrompt },
        { role: "user", content: userPrompt },
      ],
      max_tokens: MAX_TOKENS,
      temperature: TEMPERATURE,
    }),
  });

  if (!response.ok) throw new Error("重新生成题目API请求失败");
  const data = await response.json();
  const content = data.choices[0].message.content.trim();

  // 尝试解析JSON响应
  try {
    // 找到内容中的JSON部分
    const jsonMatch = content.match(/\{[\s\S]*\}/);
    if (jsonMatch) {
      const jsonString = jsonMatch[0];
      const result = JSON.parse(jsonString);

      // 检查判断题格式
      if (result.type === 3) {
        // 检查是否为问句（以问号结尾或包含特定问句词语）
        const isQuestion =
          result.content.endsWith("?") ||
          result.content.endsWith("？") ||
          /(?:是什么|什么是|如何|怎样|为什么|哪些|列举|请说明|简述|概述|说明)/.test(
            result.content
          );

        // 如果是问句，将其转换为简答题
        if (isQuestion) {
          console.log(
            "检测到格式错误的判断题，自动转换为简答题:",
            result.content
          );
          result.type = 4; // 简答题
          result.options = ""; // 清除选项
          result.answer = ""; // 清除答案
        } else {
          // 确保判断题的选项和答案格式正确
          result.options = "正确,错误";
          // 规范化答案
          result.answer =
            result.answer === "正确" || result.answer === "A" ? "正确" : "错误";
        }
      }

      // 处理填空题
      if (result.type === 2) {
        // 确保填空题没有选项
        result.options = "";

        // 计算下划线数量
        const underscoreCount = (result.content.match(/____/g) || []).length;

        // 检查答案格式
        if (underscoreCount > 0) {
          // 确保答案与下划线数量匹配
          const answerParts = result.answer
            .split(",")
            .map((a) => a.trim())
            .filter(Boolean);

          // 如果答案数量不足，复制已有答案或添加空答案
          if (answerParts.length < underscoreCount) {
            while (answerParts.length < underscoreCount) {
              if (answerParts.length > 0) {
                answerParts.push(answerParts[0]); // 复制第一个答案
              } else {
                answerParts.push("答案"); // 默认答案
              }
            }
            result.answer = answerParts.join(",");
          }
          // 如果答案数量过多，截取到匹配数量
          else if (answerParts.length > underscoreCount) {
            result.answer = answerParts.slice(0, underscoreCount).join(",");
          }
        }
      }

      // 处理简答题
      if (result.type === 4) {
        result.options = "";
        result.answer = "";
      }

      return result;
    } else {
      throw new Error("无法在响应中找到有效的JSON");
    }
  } catch (error) {
    console.error("解析重新生成题目响应失败:", error);
    console.log("AI原始响应:", content);
    throw new Error("解析重新生成内容失败，请重试");
  }
};

// 辅助函数：获取题型名称
function getTypeName(type) {
  const typeNames = {
    0: "单选题",
    1: "多选题",
    2: "填空题",
    3: "判断题",
    4: "简答题",
    single: "单选题",
    multiple: "多选题",
    fillblank: "填空题",
    truefalse: "判断题",
    shortanswer: "简答题",
  };
  return typeNames[type] || "题目";
}

// 辅助函数：获取题型代码
function getTypeCode(type) {
  const typeCodes = {
    single: 0,
    multiple: 1,
    fillblank: 2,
    truefalse: 3,
    shortanswer: 4,
    0: 0,
    1: 1,
    2: 2,
    3: 3,
    4: 4,
  };
  return typeCodes[type] !== undefined ? typeCodes[type] : 0;
}

// 辅助函数：获取难度数值
function getDifficultyNumber(difficulty) {
  const difficultyMap = {
    easy: 2,
    medium: 5,
    hard: 8,
  };
  return difficultyMap[difficulty] || 5;
}

/**
 * 刷新智能推荐方案
 * @param {Object} analysisResult - AI分析结果数据
 * @returns {Promise<Array>} - 返回推荐方案数组
 */
const refreshRecommendations = async (analysisResult) => {
  try {
    // 构建提示词
    const prompt = `
      根据以下题库分析结果，生成4个不同的智能推荐方案。每个方案必须包含：
      1. 名称（5-6个汉字）
      2. 难度级别（easy/medium/hard）
      3. 题目风格（exam/conceptual/application/creative）
      4. 题型分布（各种题型的数量）
      5. 相关关键词

      分析结果:
      ${JSON.stringify(analysisResult)}

      返回格式必须是有效的JSON数组：
      [
        {
          "label": "方案名称（5-6个汉字）",
          "difficulty": "easy/medium/hard",
          "style": "exam/practice/conceptual/application/creative",
          "types": {
            "single": 2, // 单选题数量
            "multiple": 1, // 多选题数量
            "truefalse": 1, // 判断题数量
            "fillblank": 1, // 填空题数量
            "short_answer": 2 // 简答题数量
          },
          "keywords": "关键词1,关键词2,关键词3"
        },
        // 更多方案...
      ]

      每个方案必须有明显差异，名称必须准确描述方案特点，且控制在5-6个汉字。
      不要输出任何解释性文字，只返回JSON数组。
    `;

    const systemPrompt = `你是一个智能题库推荐助手，负责根据题库分析结果生成定制的推荐方案，所有输出必须是有效的JSON格式。`;

    // 调用AI生成推荐方案
    const response = await callSiliconAI(
      prompt,
      { analysisResult },
      systemPrompt
    );

    // 解析返回结果
    let recommendations;
    try {
      // 清理AI返回的可能包含Markdown代码块的内容
      let cleanResponse = response;
      if (typeof response === "string") {
        // 移除Markdown代码块标记
        cleanResponse = response
          .replace(/```json\s*/g, "") // 移除开始的```json
          .replace(/```\s*$/g, "") // 移除结束的```
          .replace(/```/g, "") // 移除任何剩余的```标记
          .trim();

        // 确保是JSON数组格式
        if (!cleanResponse.startsWith("[")) {
          // 尝试查找JSON数组
          const jsonArrayMatch = cleanResponse.match(/\[\s*\{[\s\S]*\}\s*\]/);
          if (jsonArrayMatch) {
            cleanResponse = jsonArrayMatch[0];
          }
        }
      }

      // 解析清理后的响应
      recommendations =
        typeof cleanResponse === "string"
          ? JSON.parse(cleanResponse)
          : cleanResponse;
      if (!Array.isArray(recommendations)) {
        recommendations = [];
      }
    } catch (error) {
      console.error("解析推荐方案失败:", error);
      console.log("原始响应:", response);
      recommendations = [];
    }

    return recommendations;
  } catch (error) {
    console.error("刷新推荐方案失败:", error);
    throw error;
  }
};

export default callSiliconAI;
export {
  quickGenerateBank,
  generateTemplates,
  generateWithReference,
  regenerateQuestion,
  refreshRecommendations,
};
